/*
 * Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package javax.management.openmbean;

import com.sun.jmx.mbeanserver.MXBeanLookup;
import com.sun.jmx.mbeanserver.MXBeanMapping;
import com.sun.jmx.mbeanserver.MXBeanMappingFactory;
import com.sun.jmx.mbeanserver.DefaultMXBeanMappingFactory;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * <p>An {@link InvocationHandler} that forwards getter methods to a
 * {@link CompositeData}.  If you have an interface that contains
 * only getter methods (such as {@code String getName()} or
 * {@code boolean isActive()}) then you can use this class in
 * conjunction with the {@link Proxy} class to produce an implementation
 * of the interface where each getter returns the value of the
 * corresponding item in a {@code CompositeData}.</p>
 *
 * <p>For example, suppose you have an interface like this:
 *
 * <blockquote>
 * <pre>
 * public interface NamedNumber {
 * public int getNumber();
 * public String getName();
 * }
 * </pre>
 * </blockquote>
 *
 * and a {@code CompositeData} constructed like this:
 *
 * <blockquote>
 * <pre>
 * CompositeData cd =
 * new {@link CompositeDataSupport}(
 * someCompositeType,
 * new String[] {"number", "name"},
 * new Object[] {<b>5</b>, "five"}
 * );
 * </pre>
 * </blockquote>
 *
 * then you can construct an object implementing {@code NamedNumber}
 * and backed by the object {@code cd} like this:
 *
 * <blockquote>
 * <pre>
 * InvocationHandler handler =
 * new CompositeDataInvocationHandler(cd);
 * NamedNumber nn = (NamedNumber)
 * Proxy.newProxyInstance(NamedNumber.class.getClassLoader(),
 * new Class[] {NamedNumber.class},
 * handler);
 * </pre>
 * </blockquote>
 *
 * A call to {@code nn.getNumber()} will then return <b>5</b>.
 *
 * <p>If the first letter of the property defined by a getter is a
 * capital, then this handler will look first for an item in the
 * {@code CompositeData} beginning with a capital, then, if that is
 * not found, for an item beginning with the corresponding lowercase
 * letter or code point.  For a getter called {@code getNumber()}, the
 * handler will first look for an item called {@code Number}, then for
 * {@code number}.  If the getter is called {@code getnumber()}, then
 * the item must be called {@code number}.</p>
 *
 * <p>If the method given to {@link #invoke invoke} is the method
 * {@code boolean equals(Object)} inherited from {@code Object}, then
 * it will return true if and only if the argument is a {@code Proxy}
 * whose {@code InvocationHandler} is also a {@code
 * CompositeDataInvocationHandler} and whose backing {@code
 * CompositeData} is equal (not necessarily identical) to this
 * object's.  If the method given to {@code invoke} is the method
 * {@code int hashCode()} inherited from {@code Object}, then it will
 * return a value that is consistent with this definition of {@code
 * equals}: if two objects are equal according to {@code equals}, then
 * they will have the same {@code hashCode}.</p>
 *
 * @since 1.6
 */
public class CompositeDataInvocationHandler implements InvocationHandler {

  /**
   * <p>Construct a handler backed by the given {@code
   * CompositeData}.</p>
   *
   * @param compositeData the {@code CompositeData} that will supply information to getters.
   * @throws IllegalArgumentException if {@code compositeData} is null.
   */
  public CompositeDataInvocationHandler(CompositeData compositeData) {
    this(compositeData, null);
  }

  /**
   * <p>Construct a handler backed by the given {@code
   * CompositeData}.</p>
   *
   * @param compositeData the {@code CompositeData} that will supply information to getters.
   * @throws IllegalArgumentException if {@code compositeData} is null.
   */
  CompositeDataInvocationHandler(CompositeData compositeData,
      MXBeanLookup lookup) {
    if (compositeData == null) {
      throw new IllegalArgumentException("compositeData");
    }
    this.compositeData = compositeData;
    this.lookup = lookup;
  }

  /**
   * Return the {@code CompositeData} that was supplied to the
   * constructor.
   *
   * @return the {@code CompositeData} that this handler is backed by.  This is never null.
   */
  public CompositeData getCompositeData() {
    assert compositeData != null;
    return compositeData;
  }

  public Object invoke(Object proxy, Method method, Object[] args)
      throws Throwable {
    final String methodName = method.getName();

    // Handle the methods from java.lang.Object
    if (method.getDeclaringClass() == Object.class) {
      if (methodName.equals("toString") && args == null) {
        return "Proxy[" + compositeData + "]";
      } else if (methodName.equals("hashCode") && args == null) {
        return compositeData.hashCode() + 0x43444948;
      } else if (methodName.equals("equals") && args.length == 1
          && method.getParameterTypes()[0] == Object.class) {
        return equals(proxy, args[0]);
      } else {
                /* Either someone is calling invoke by hand, or
                   it is a non-final method from Object overriden
                   by the generated Proxy.  At the time of writing,
                   the only non-final methods in Object that are not
                   handled above are finalize and clone, and these
                   are not overridden in generated proxies.  */
        // this plain Method.invoke is called only if the declaring class
        // is Object and so it's safe.
        return method.invoke(this, args);
      }
    }

    String propertyName = DefaultMXBeanMappingFactory.propertyName(method);
    if (propertyName == null) {
      throw new IllegalArgumentException("Method is not getter: " +
          method.getName());
    }
    Object openValue;
    if (compositeData.containsKey(propertyName)) {
      openValue = compositeData.get(propertyName);
    } else {
      String decap = DefaultMXBeanMappingFactory.decapitalize(propertyName);
      if (compositeData.containsKey(decap)) {
        openValue = compositeData.get(decap);
      } else {
        final String msg =
            "No CompositeData item " + propertyName +
                (decap.equals(propertyName) ? "" : " or " + decap) +
                " to match " + methodName;
        throw new IllegalArgumentException(msg);
      }
    }
    MXBeanMapping mapping =
        MXBeanMappingFactory.DEFAULT.mappingForType(method.getGenericReturnType(),
            MXBeanMappingFactory.DEFAULT);
    return mapping.fromOpenValue(openValue);
  }

  /* This method is called when equals(Object) is
   * called on our proxy and hence forwarded to us.  For example, if we
   * are a proxy for an interface like this:
   * public interface GetString {
   *     public String string();
   * }
   * then we must compare equal to another CompositeDataInvocationHandler
   * proxy for the same interface and where string() returns the same value.
   *
   * You might think that we should also compare equal to another
   * object that implements GetString directly rather than using
   * Proxy, provided that its string() returns the same result as
   * ours, and in fact an earlier version of this class did that (by
   * converting the other object into a CompositeData and comparing
   * that with ours).  But in fact that doesn't make a great deal of
   * sense because there's absolutely no guarantee that the
   * resulting equals would be reflexive (otherObject.equals(this)
   * might be false even if this.equals(otherObject) is true), and,
   * especially, there's no way we could generate a hashCode() that
   * would be equal to otherObject.hashCode() when
   * this.equals(otherObject), because we don't know how
   * otherObject.hashCode() is computed.
   */
  private boolean equals(Object proxy, Object other) {
    if (other == null) {
      return false;
    }

    final Class<?> proxyClass = proxy.getClass();
    final Class<?> otherClass = other.getClass();
    if (proxyClass != otherClass) {
      return false;
    }
    InvocationHandler otherih = Proxy.getInvocationHandler(other);
    if (!(otherih instanceof CompositeDataInvocationHandler)) {
      return false;
    }
    CompositeDataInvocationHandler othercdih =
        (CompositeDataInvocationHandler) otherih;
    return compositeData.equals(othercdih.compositeData);
  }

  private final CompositeData compositeData;
  private final MXBeanLookup lookup;
}
